using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("StoreManager")]
	public class StoreManager : MonoClass
	{
		public enum PurchaseErrorSource
		{
			FROM_PURCHASE_METHOD_RESPONSE,
			FROM_STATUS_OR_PURCHASE_RESPONSE,
			FROM_PREVIOUS_PURCHASE
		}

		public enum TransactionStatus
		{
			UNKNOWN,
			IN_PROGRESS_MONEY,
			IN_PROGRESS_GOLD_GTAPP,
			IN_PROGRESS_GOLD_NO_GTAPP,
			READY,
			WAIT_ZERO_COST_LICENSE,
			WAIT_METHOD_OF_PAYMENT,
			WAIT_THIRD_PARTY_INIT,
			WAIT_THIRD_PARTY_RECEIPT,
			WAIT_CONFIRM,
			WAIT_RISK,
			CHALLENGE_SUBMITTED,
			CHALLENGE_CANCELED,
			USER_CANCELING,
			AUTO_CANCELING
		}

		[Attribute38("StoreManager.StoreAchievesData")]
		public class StoreAchievesData : MonoClass
		{
			public Network.Bundle Bundle => method_14<Network.Bundle>("get_Bundle", Array.Empty<object>());

			public PaymentMethod MethodOfPayment => method_11<PaymentMethod>("get_MethodOfPayment", Array.Empty<object>());

			public StoreAchievesData(IntPtr address, string className)
				: base(address, className)
			{
			}

			public StoreAchievesData(IntPtr address)
				: this(address, "StoreAchievesData")
			{
			}
		}

		[Attribute38("StoreManager.ZeroCostTransactionData")]
		public class ZeroCostTransactionData : MonoClass
		{
			public Network.Bundle Bundle => method_14<Network.Bundle>("get_Bundle", Array.Empty<object>());

			public ZeroCostTransactionData(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ZeroCostTransactionData(IntPtr address)
				: this(address, "ZeroCostTransactionData")
			{
			}
		}

		public struct ShowStoreData
		{
			public bool m_isTotallyFake;

			public object m_exitCallbackUserData;

			public int m_storeProductData;

			public GeneralStoreMode m_storeMode;

			public ZeroCostTransactionData m_zeroCostTransactionData;
		}

		public static int DEFAULT_SECONDS_BEFORE_AUTO_CANCEL => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "StoreManager", "DEFAULT_SECONDS_BEFORE_AUTO_CANCEL");

		public static int DEFAULT_SECONDS_BEFORE_AUTO_CANCEL_THIRD_PARTY => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "StoreManager", "DEFAULT_SECONDS_BEFORE_AUTO_CANCEL_THIRD_PARTY");

		public static int NO_ITEM_COUNT_REQUIREMENT => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "StoreManager", "NO_ITEM_COUNT_REQUIREMENT");

		public static int NO_PRODUCT_DATA_REQUIREMENT => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "StoreManager", "NO_PRODUCT_DATA_REQUIREMENT");

		public static int UNKNOWN_TRANSACTION_ID => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "StoreManager", "UNKNOWN_TRANSACTION_ID");

		public bool m_featuresReady => method_2<bool>("m_featuresReady");

		public bool m_initComplete => method_2<bool>("m_initComplete");

		public bool m_battlePayAvailable => method_2<bool>("m_battlePayAvailable");

		public bool m_firstNoticesProcessed => method_2<bool>("m_firstNoticesProcessed");

		public bool m_firstMoneyOrGTAPPTransactionSet => method_2<bool>("m_firstMoneyOrGTAPPTransactionSet");

		public long m_ticksBeforeAutoCancel => method_2<long>("m_ticksBeforeAutoCancel");

		public long m_ticksBeforeAutoCancelThirdParty => method_2<long>("m_ticksBeforeAutoCancelThirdParty");

		public long m_lastCancelRequestTime => method_2<long>("m_lastCancelRequestTime");

		public bool m_configLoaded => method_2<bool>("m_configLoaded");

		public Currency m_currency => method_3<Currency>("m_currency");

		public StoreType m_currentStoreType => method_2<StoreType>("m_currentStoreType");

		public float m_showStoreStart => method_2<float>("m_showStoreStart");

		public Network.PurchaseMethod m_challengePurchaseMethod => method_3<Network.PurchaseMethod>("m_challengePurchaseMethod");

		public bool m_openWhenLastEventFired => method_2<bool>("m_openWhenLastEventFired");

		public TransactionStatus m_status => method_2<TransactionStatus>("m_status");

		public StorePurchaseAuth m_storePurchaseAuth => method_3<StorePurchaseAuth>("m_storePurchaseAuth");

		public StoreSummary m_storeSummary => method_3<StoreSummary>("m_storeSummary");

		public StoreSendToBAM m_storeSendToBAM => method_3<StoreSendToBAM>("m_storeSendToBAM");

		public StoreLegalBAMLinks m_storeLegalBAMLinks => method_3<StoreLegalBAMLinks>("m_storeLegalBAMLinks");

		public StoreDoneWithBAM m_storeDoneWithBAM => method_3<StoreDoneWithBAM>("m_storeDoneWithBAM");

		public StoreChallengePrompt m_storeChallengePrompt => method_3<StoreChallengePrompt>("m_storeChallengePrompt");

		public bool m_waitingToShowStore => method_2<bool>("m_waitingToShowStore");

		public ShowStoreData m_showStoreData => method_2<ShowStoreData>("m_showStoreData");

		public MoneyOrGTAPPTransaction m_activeMoneyOrGTAPPTransaction => method_3<MoneyOrGTAPPTransaction>("m_activeMoneyOrGTAPPTransaction");

		public List<NetCache.ProfileNoticePurchase> m_outstandingPurchaseNotices => method_3<Class271<NetCache.ProfileNoticePurchase>>("m_outstandingPurchaseNotices")?.method_25();

		public List<Achievement> m_completedAchieves => method_3<Class271<Achievement>>("m_completedAchieves")?.method_25();

		public bool m_licenseAchievesListenerRegistered => method_2<bool>("m_licenseAchievesListenerRegistered");

		public string m_requestedThirdPartyProductId => method_4("m_requestedThirdPartyProductId");

		public bool m_shouldAutoCancelThirdPartyTransaction => method_2<bool>("m_shouldAutoCancelThirdPartyTransaction");

		public TransactionStatus m_previousStatusBeforeAutoCancel => method_2<TransactionStatus>("m_previousStatusBeforeAutoCancel");

		public bool m_outOfSessionThirdPartyTransaction => method_2<bool>("m_outOfSessionThirdPartyTransaction");

		public TransactionStatus Status => method_11<TransactionStatus>("get_Status", Array.Empty<object>());

		public bool FirstNoticesProcessed => method_11<bool>("get_FirstNoticesProcessed", Array.Empty<object>());

		public bool BattlePayAvailable => method_11<bool>("get_BattlePayAvailable", Array.Empty<object>());

		public bool FeaturesReady => method_11<bool>("get_FeaturesReady", Array.Empty<object>());

		public bool ConfigLoaded => method_11<bool>("get_ConfigLoaded", Array.Empty<object>());

		public StoreManager(IntPtr address, string className)
			: base(address, className)
		{
		}

		public StoreManager(IntPtr address)
			: this(address, "StoreManager")
		{
		}

		public static StoreManager Get()
		{
			return MonoClass.smethod_15<StoreManager>(TritonHs.MainAssemblyPath, "", "StoreManager", "Get", Array.Empty<object>());
		}

		public static void DestroyInstance()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "StoreManager", "DestroyInstance");
		}

		public static bool IsFirstPurchaseBundleBooster(int boosterId)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "StoreManager", "IsFirstPurchaseBundleBooster", new object[1] { boosterId });
		}

		public static bool IsFirstPurchaseBundleOwned()
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "StoreManager", "IsFirstPurchaseBundleOwned", Array.Empty<object>());
		}

		public void NetworkRegistration()
		{
			method_8("NetworkRegistration");
		}

		public void Init()
		{
			method_8("Init");
		}

		public void WillReset()
		{
			method_8("WillReset");
		}

		public void Heartbeat()
		{
			method_8("Heartbeat");
		}

		public bool IsOpen()
		{
			return method_11<bool>("IsOpen", Array.Empty<object>());
		}

		public bool IsStoreFeatureEnabled()
		{
			return method_11<bool>("IsStoreFeatureEnabled", Array.Empty<object>());
		}

		public bool IsBattlePayFeatureEnabled()
		{
			return method_11<bool>("IsBattlePayFeatureEnabled", Array.Empty<object>());
		}

		public bool IsBuyWithGoldFeatureEnabled()
		{
			return method_11<bool>("IsBuyWithGoldFeatureEnabled", Array.Empty<object>());
		}

		public bool IsWaitingToShow()
		{
			return method_11<bool>("IsWaitingToShow", Array.Empty<object>());
		}

		public Store GetCurrentStore()
		{
			return method_14<Store>("GetCurrentStore", Array.Empty<object>());
		}

		public Store GetStore(StoreType storeType)
		{
			return method_14<Store>("GetStore", new object[1] { storeType });
		}

		public bool IsShown()
		{
			return method_11<bool>("IsShown", Array.Empty<object>());
		}

		public bool IsShownOrWaitingToShow()
		{
			return method_11<bool>("IsShownOrWaitingToShow", Array.Empty<object>());
		}

		public Network.Bundle GetBundle(string productID)
		{
			return method_14<Network.Bundle>("GetBundle", new object[1] { productID });
		}

		public bool IsProductAlreadyOwned(Network.Bundle bundle)
		{
			return method_11<bool>("IsProductAlreadyOwned", new object[1] { bundle });
		}

		public bool IsProductFree(Network.Bundle bundle)
		{
			return method_11<bool>("IsProductFree", new object[1] { bundle });
		}

		public bool IsProductPrePurchase(Network.Bundle bundle)
		{
			return method_11<bool>("IsProductPrePurchase", new object[1] { bundle });
		}

		public bool IsProductFirstPurchaseBundle(Network.Bundle bundle)
		{
			return method_11<bool>("IsProductFirstPurchaseBundle", new object[1] { bundle });
		}

		public bool CanBuyBoosterWithGold(int boosterDbId)
		{
			return method_11<bool>("CanBuyBoosterWithGold", new object[1] { boosterDbId });
		}

		public bool IsChinaCustomer()
		{
			return method_11<bool>("IsChinaCustomer", Array.Empty<object>());
		}

		public bool IsKoreanCustomer()
		{
			return method_11<bool>("IsKoreanCustomer", Array.Empty<object>());
		}

		public bool IsEuropeanCustomer()
		{
			return method_11<bool>("IsEuropeanCustomer", Array.Empty<object>());
		}

		public bool IsNorthAmericanCustomer()
		{
			return method_11<bool>("IsNorthAmericanCustomer", Array.Empty<object>());
		}

		public string GetTaxText()
		{
			return method_13("GetTaxText");
		}

		public int GetCurrencyChangedVersion()
		{
			return method_11<int>("GetCurrencyChangedVersion", Array.Empty<object>());
		}

		public string FormatCostBundle(Network.Bundle bundle)
		{
			return method_13("FormatCostBundle", bundle);
		}

		public void GetThirdPartyPurchaseStatus(string transactionID)
		{
			method_8("GetThirdPartyPurchaseStatus", transactionID);
		}

		public void StartGeneralTransaction()
		{
			method_9("StartGeneralTransaction", new Class276.Enum20[0]);
		}

		public void StartGeneralTransaction(GeneralStoreMode mode)
		{
			method_9("StartGeneralTransaction", new Class276.Enum20[1] { Class276.Enum20.ValueType }, mode);
		}

		public void HideStore(StoreType storeType)
		{
			method_8("HideStore", storeType);
		}

		public bool TransactionInProgress()
		{
			return method_11<bool>("TransactionInProgress", Array.Empty<object>());
		}

		public bool IsPromptShowing()
		{
			return method_11<bool>("IsPromptShowing", Array.Empty<object>());
		}

		public bool IsIdActiveTransaction(long id)
		{
			return method_11<bool>("IsIdActiveTransaction", new object[1] { id });
		}

		public void ShowStoreWhenLoaded()
		{
			method_8("ShowStoreWhenLoaded");
		}

		public void ShowStore()
		{
			method_8("ShowStore");
		}

		public void OnStoreShown()
		{
			method_8("OnStoreShown");
		}

		public bool ShouldEnablePurchaseAuthBackButton(StoreType storeType)
		{
			return method_11<bool>("ShouldEnablePurchaseAuthBackButton", new object[1] { storeType });
		}

		public bool IsCurrentStoreLoaded()
		{
			return method_11<bool>("IsCurrentStoreLoaded", Array.Empty<object>());
		}

		public void Load(StoreType storeType)
		{
			method_8("Load", storeType);
		}

		public void UnloadAndFreeMemory()
		{
			method_8("UnloadAndFreeMemory");
		}

		public void FireStatusChangedEventIfNeeded()
		{
			method_8("FireStatusChangedEventIfNeeded");
		}

		public NetCache.NetCacheFeatures GetNetCacheFeatures()
		{
			return method_14<NetCache.NetCacheFeatures>("GetNetCacheFeatures", Array.Empty<object>());
		}

		public string GetSingleItemProductName(Network.BundleItem item)
		{
			return method_13("GetSingleItemProductName", item);
		}

		public bool AutoCancelPurchaseIfNeeded(long now)
		{
			return method_11<bool>("AutoCancelPurchaseIfNeeded", new object[1] { now });
		}

		public bool AutoCancelPurchaseIfPossible()
		{
			return method_11<bool>("AutoCancelPurchaseIfPossible", Array.Empty<object>());
		}

		public bool HaveProductsToSell()
		{
			return method_11<bool>("HaveProductsToSell", Array.Empty<object>());
		}

		public bool IsBundleRealMoneyOptionAvailableNow(Network.Bundle bundle)
		{
			return method_11<bool>("IsBundleRealMoneyOptionAvailableNow", new object[1] { bundle });
		}

		public bool IsBundleGoldOptionAvailableNow(Network.Bundle bundle)
		{
			return method_11<bool>("IsBundleGoldOptionAvailableNow", new object[1] { bundle });
		}

		public bool IsBundleAvailableNow(Network.Bundle bundle, bool requireRealMoneyOption)
		{
			return method_11<bool>("IsBundleAvailableNow", new object[2] { bundle, requireRealMoneyOption });
		}

		public bool DoesBundleContainDust(Network.Bundle bundle)
		{
			return method_11<bool>("DoesBundleContainDust", new object[1] { bundle });
		}

		public int DustQuantityInBundle(Network.Bundle bundle)
		{
			return method_11<int>("DustQuantityInBundle", new object[1] { bundle });
		}

		public int PackQuantityInBundle(Network.Bundle bundle)
		{
			return method_11<int>("PackQuantityInBundle", new object[1] { bundle });
		}

		public void OnStoreExit(bool authorizationBackButtonPressed, object userData)
		{
			method_8("OnStoreExit", authorizationBackButtonPressed, userData);
		}

		public void OnStoreInfo(object userData)
		{
			method_8("OnStoreInfo", userData);
		}

		public bool CanBuyBundle(Network.Bundle bundleToBuy)
		{
			return method_11<bool>("CanBuyBundle", new object[1] { bundleToBuy });
		}

		public void OnStoreBuyWithMoney(string productID, int quantity, object userData)
		{
			method_8("OnStoreBuyWithMoney", productID, quantity, userData);
		}

		public void OnStoreBuyWithGTAPP(string productID, int quantity, object userData)
		{
			method_8("OnStoreBuyWithGTAPP", productID, quantity, userData);
		}

		public void OnStoreBuyWithGoldNoGTAPP(NoGTAPPTransactionData noGTAPPtransactionData, object userData)
		{
			method_8("OnStoreBuyWithGoldNoGTAPP", noGTAPPtransactionData, userData);
		}

		public void OnSummaryConfirm(string productID, int quantity, object userData)
		{
			method_8("OnSummaryConfirm", productID, quantity, userData);
		}

		public void ConfirmPurchase()
		{
			method_8("ConfirmPurchase");
		}

		public void OnSummaryCancel(object userData)
		{
			method_8("OnSummaryCancel", userData);
		}

		public void OnThirdPartyPurchaseApproved()
		{
			method_8("OnThirdPartyPurchaseApproved");
		}

		public void OnSummaryInfo(object userData)
		{
			method_8("OnSummaryInfo", userData);
		}

		public void OnSummaryPaymentAndTOS(object userData)
		{
			method_8("OnSummaryPaymentAndTOS", userData);
		}

		public void OnChallengeCancel(string challengeID)
		{
			method_8("OnChallengeCancel", challengeID);
		}

		public void OnSendToBAMOkay(MoneyOrGTAPPTransaction moneyOrGTAPPTransaction, StoreSendToBAM.BAMReason reason)
		{
			method_8("OnSendToBAMOkay", moneyOrGTAPPTransaction, reason);
		}

		public void OnSendToBAMCancel(MoneyOrGTAPPTransaction moneyOrGTAPPTransaction)
		{
			method_8("OnSendToBAMCancel", moneyOrGTAPPTransaction);
		}

		public void OnSendToBAMLegal(StoreLegalBAMLinks.BAMReason reason)
		{
			method_8("OnSendToBAMLegal", reason);
		}

		public void OnSendToBAMLegalCancel()
		{
			method_8("OnSendToBAMLegalCancel");
		}

		public void OnDoneWithBAM()
		{
			method_8("OnDoneWithBAM");
		}

		public void ShowCompletedAchieve()
		{
			method_8("ShowCompletedAchieve");
		}

		public void OnPurchaseResultAcknowledged(bool success, MoneyOrGTAPPTransaction moneyOrGTAPPTransaction)
		{
			method_8("OnPurchaseResultAcknowledged", success, moneyOrGTAPPTransaction);
		}

		public void OnAuthExit()
		{
			method_8("OnAuthExit");
		}

		public void ActivateStoreCover()
		{
			method_8("ActivateStoreCover");
		}

		public void DeactivateStoreCover()
		{
			method_8("DeactivateStoreCover");
		}

		public void HandleFailedRiskError(PurchaseErrorSource source)
		{
			method_8("HandleFailedRiskError", source);
		}

		public void HandleSendToBAMError(PurchaseErrorSource source, StoreSendToBAM.BAMReason reason, string errorCode)
		{
			method_8("HandleSendToBAMError", source, reason, errorCode);
		}

		public void NotifyMobileGamePurchaseResponse(string thirdPartyID, bool isSuccess)
		{
			method_8("NotifyMobileGamePurchaseResponse", thirdPartyID, isSuccess);
		}

		public void CompletePurchaseFailure(PurchaseErrorSource source, MoneyOrGTAPPTransaction moneyOrGTAPPTransaction, string failDetails, string thirdPartyID, bool removeThirdPartyReceipt, Network.PurchaseErrorInfo.ErrorType error)
		{
			method_8("CompletePurchaseFailure", source, moneyOrGTAPPTransaction, failDetails, thirdPartyID, removeThirdPartyReceipt, error);
		}

		public void HandlePurchaseError(PurchaseErrorSource source, Network.PurchaseErrorInfo.ErrorType purchaseErrorType, string purchaseErrorCode, string thirdPartyID, bool isGTAPP)
		{
			method_8("HandlePurchaseError", source, purchaseErrorType, purchaseErrorCode, thirdPartyID, isGTAPP);
		}

		public void ResolveFirstMoneyOrGTAPPTransactionIfPossible()
		{
			method_8("ResolveFirstMoneyOrGTAPPTransactionIfPossible");
		}

		public void ConfirmActiveMoneyTransaction(long id)
		{
			method_8("ConfirmActiveMoneyTransaction", id);
		}

		public void RemoveThirdPartyReceipt(string transactionID)
		{
			method_8("RemoveThirdPartyReceipt", transactionID);
		}

		public void OnGoldBalanceChanged(NetCache.NetCacheGoldBalance balance)
		{
			method_8("OnGoldBalanceChanged", balance);
		}

		public void OnNetCacheFeaturesReady()
		{
			method_8("OnNetCacheFeaturesReady");
		}

		public void OnPurchaseCanceledResponse()
		{
			method_8("OnPurchaseCanceledResponse");
		}

		public bool IsConclusiveState(Network.PurchaseErrorInfo.ErrorType errorType)
		{
			return method_11<bool>("IsConclusiveState", new object[1] { errorType });
		}

		public bool IsSafeToRemoveMobileReceipt(Network.PurchaseErrorInfo.ErrorType errorType)
		{
			return method_11<bool>("IsSafeToRemoveMobileReceipt", new object[1] { errorType });
		}

		public void OnBattlePayStatusResponse()
		{
			method_8("OnBattlePayStatusResponse");
		}

		public void OnBattlePayConfigResponse()
		{
			method_8("OnBattlePayConfigResponse");
		}

		public void HandleZeroCostLicensePurchaseMethod(Network.PurchaseMethod method)
		{
			method_8("HandleZeroCostLicensePurchaseMethod", method);
		}

		public void OnPurchaseMethod()
		{
			method_8("OnPurchaseMethod");
		}

		public void OnPurchaseResponse()
		{
			method_8("OnPurchaseResponse");
		}

		public void OnPurchaseViaGoldResponse()
		{
			method_8("OnPurchaseViaGoldResponse");
		}

		public void OnThirdPartyPurchaseStatusResponse()
		{
			method_8("OnThirdPartyPurchaseStatusResponse");
		}

		public void OnStoreComponentReady(object userData)
		{
			method_8("OnStoreComponentReady", userData);
		}

		public void OnGeneralStoreLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnGeneralStoreLoaded", assetRef, go, callbackData);
		}

		public void OnArenaStoreLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnArenaStoreLoaded", assetRef, go, callbackData);
		}

		public void OnHeroicBrawlStoreLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnHeroicBrawlStoreLoaded", assetRef, go, callbackData);
		}

		public void OnAdventureStoreLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnAdventureStoreLoaded", assetRef, go, callbackData);
		}

		public void SetupLoadedStore(Store store)
		{
			method_8("SetupLoadedStore", store);
		}

		public void OnStorePurchaseAuthLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnStorePurchaseAuthLoaded", assetRef, go, callbackData);
		}

		public void OnStoreSummaryLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnStoreSummaryLoaded", assetRef, go, callbackData);
		}

		public void OnStoreSendToBAMLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnStoreSendToBAMLoaded", assetRef, go, callbackData);
		}

		public void OnStoreLegalBAMLinksLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnStoreLegalBAMLinksLoaded", assetRef, go, callbackData);
		}

		public void OnStoreDoneWithBAMLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnStoreDoneWithBAMLoaded", assetRef, go, callbackData);
		}

		public void OnStoreChallengePromptLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnStoreChallengePromptLoaded", assetRef, go, callbackData);
		}

		public void OnSceneUnloaded(SceneMgr.Mode prevMode, PegasusScene prevScene, object userData)
		{
			method_8("OnSceneUnloaded", prevMode, prevScene, userData);
		}

		public void HideAllPurchasePopups()
		{
			method_8("HideAllPurchasePopups");
		}
	}
}
